package correctness;

import static org.junit.Assert.*;

import java.util.Map;

import model.LogicType;
import model.editormodel.EditorModel;
import model.editormodel.Input;
import model.editormodel.LogicEditorElement;
import model.editormodel.Output;
import model.simulationmodel.LogicValue;
import model.simulationmodel.SimulationModel;

import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

/**
 * Diese Klasse testet stichprobenartig, ob die Simulation einer Schaltung
 * korrekte Ergebnisse liefert
 * 
 * @author Team Locsi
 * 
 */
public class circuit1Test {

	private static EditorModel eModel;
	private static SimulationModel sModel;

	/**
	 * Diese Methode initialisiert die Attribute. Ausserdem wird eine Schaltung
	 * erstellt
	 */
	@BeforeClass
	public static void initialize() {
		eModel = new EditorModel();
		// Schalter hinzufuegen
		eModel.addLogicElement(LogicType.SWITCH, "swit", 1, 1); // 1
		eModel.addLogicElement(LogicType.SWITCH, "swit", 1, 20); // 2
		eModel.addLogicElement(LogicType.SWITCH, "swit", 1, 40); // 3
		eModel.addLogicElement(LogicType.SWITCH, "swit", 1, 60); // 4
		eModel.addLogicElement(LogicType.SWITCH, "swit", 1, 80); // 5
		eModel.addLogicElement(LogicType.SWITCH, "swit", 1, 100); // 6
		eModel.addLogicElement(LogicType.SWITCH, "swit", 1, 120); // 7
		eModel.addLogicElement(LogicType.SWITCH, "swit", 1, 140); // 8
		eModel.addLogicElement(LogicType.SWITCH, "swit", 1, 160); // 9

		// Bauteile hinzufuegen
		eModel.addLogicElement(LogicType.NOT, "not", 30, 1); // 10
		eModel.addLogicElement(LogicType.XOR, "xor", 30, 30); // 11
		eModel.addLogicElement(LogicType.TWO_MX, "2mx", 30, 60); // 12
		eModel.addLogicElement(LogicType.OR, "or", 30, 90); // 13
		eModel.addLogicElement(LogicType.NAND, "nand", 30, 120); // 14
		eModel.addLogicElement(LogicType.AND, "and", 30, 150); // 15
		eModel.addLogicElement(LogicType.FLIPFLOP, "flipflop", 30, 180); // 16
		eModel.addLogicElement(LogicType.NOT, "not", 60, 120); // 17
		eModel.addLogicElement(LogicType.NODE, "node", 90, 120); // 18
		eModel.addLogicElement(LogicType.OR, "or", 60, 180); // 19

		// Lampen hinzufuegen
		eModel.addLogicElement(LogicType.LAMP, "lamp", 90, 1); // 20
		eModel.addLogicElement(LogicType.LAMP, "lamp", 90, 30); // 21
		eModel.addLogicElement(LogicType.LAMP, "lamp", 90, 60); // 22
		eModel.addLogicElement(LogicType.LAMP, "lamp", 90, 90); // 23
		eModel.addLogicElement(LogicType.LAMP, "lamp", 90, 120); // 24
		eModel.addLogicElement(LogicType.LAMP, "lamp", 90, 150); // 25
		eModel.addLogicElement(LogicType.LAMP, "lamp", 90, 180); // 26

		// Leitungen hinzufuegen
		eModel.setConnection(
				getEditorElement().get("swit_1").getOutputs().get(Output.STD_O),
				getEditorElement().get("not_10").getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("swit_2").getOutputs().get(Output.STD_O),
				getEditorElement().get("xor_11").getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("swit_3").getOutputs().get(Output.STD_O),
				getEditorElement().get("xor_11").getInputs().get(Input.STD_B));
		eModel.setConnection(
				getEditorElement().get("swit_4").getOutputs().get(Output.STD_O),
				getEditorElement().get("2mx_12").getInputs().get(Input.SELECT));
		eModel.setConnection(
				getEditorElement().get("swit_5").getOutputs().get(Output.STD_O),
				getEditorElement().get("or_13").getInputs().get(Input.STD_B));
		eModel.setConnection(
				getEditorElement().get("swit_6").getOutputs().get(Output.STD_O),
				getEditorElement().get("nand_14").getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("swit_7").getOutputs().get(Output.STD_O),
				getEditorElement().get("nand_14").getInputs().get(Input.STD_B));
		eModel.setConnection(
				getEditorElement().get("swit_8").getOutputs().get(Output.STD_O),
				getEditorElement().get("flipflop_16").getInputs()
						.get(Input.FF_SET));
		eModel.setConnection(
				getEditorElement().get("swit_9").getOutputs().get(Output.STD_O),
				getEditorElement().get("flipflop_16").getInputs()
						.get(Input.FF_RESET));
		eModel.setConnection(
				getEditorElement().get("not_10").getOutputs().get(Output.STD_O),
				getEditorElement().get("lamp_20").getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("not_10").getOutputs().get(Output.STD_O),
				getEditorElement().get("2mx_12").getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("xor_11").getOutputs().get(Output.STD_O),
				getEditorElement().get("lamp_21").getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("xor_11").getOutputs().get(Output.STD_O),
				getEditorElement().get("2mx_12").getInputs().get(Input.STD_B));
		eModel.setConnection(
				getEditorElement().get("2mx_12").getOutputs().get(Output.STD_O),
				getEditorElement().get("lamp_22").getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("2mx_12").getOutputs().get(Output.STD_O),
				getEditorElement().get("or_13").getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("or_13").getOutputs().get(Output.STD_O),
				getEditorElement().get("lamp_23").getInputs().get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("nand_14").getOutputs()
				.get(Output.STD_O), getEditorElement().get("not_17")
				.getInputs().get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("nand_14").getOutputs()
				.get(Output.STD_O), getEditorElement().get("and_15")
				.getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("not_17").getOutputs().get(Output.STD_O),
				getEditorElement().get("and_15").getInputs().get(Input.STD_B));
		eModel.setConnection(
				getEditorElement().get("not_17").getOutputs().get(Output.STD_O),
				getEditorElement().get("node_18").getInputs().get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("node_18").getOutputs()
				.get(Output.STD_O), getEditorElement().get("lamp_24")
				.getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("and_15").getOutputs().get(Output.STD_O),
				getEditorElement().get("lamp_25").getInputs().get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("flipflop_16").getOutputs()
				.get(Output.FF_Q), getEditorElement().get("or_19").getInputs()
				.get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("flipflop_16").getOutputs()
				.get(Output.FF_NQ), getEditorElement().get("or_19").getInputs()
				.get(Input.STD_B));
		eModel.setConnection(
				getEditorElement().get("or_19").getOutputs().get(Output.STD_O),
				getEditorElement().get("lamp_26").getInputs().get(Input.STD_A));
		sModel = new SimulationModel(eModel);
		sModel.updateSimulationElements();

	}

	/**
	 * Diese Methode wird vor jeder Test-Methode aufgerufen. Die Attribute
	 * werden auf den Ausgangszustand zurueck gesetzt
	 */
	@Before
	public void reset() {
		initialize();
	}

	/**
	 * private HilfsMethode um alles Elemete des CircuitModels zu bekommen
	 * 
	 * @return Map<<code>String, LogicEditorElement></code> - alle Elemete einer
	 *         Schaltung
	 */
	private static Map<String, LogicEditorElement> getEditorElement() {
		return eModel.getCircuitModel().getUnmodifableElementsOnEditor();
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter:
	 * aller Schalter auf L0.
	 */
	@Test
	public void testBelegung1() {

		// Schalter setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_1"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_2"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_3"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_4"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_5"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_6"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_7"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_8"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_9"))
				.setInputValue(Input.STD_A, LogicValue.L0);

		// Schaltung Simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);

		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);

		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);

		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);

		assertTrue(
				"Belegung des Lampe24 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_24"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);
		assertTrue(
				"Belegung des Lampe25 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_25"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);

		assertTrue(
				"Belegung des Lampe26 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_26"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		sModel.stopSimulation();
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter:
	 * Schalter1: L1, Schalter2: L1, Schalter3: L0, Schalter4: L1, Schalter5:
	 * L1, Schalter6: L0, Schalter7: L1, Schalter8: L0, Schalter9: L1
	 * 
	 */
	@Test
	public void testBelegung2() {

		// Schalter setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_1"))
				.setInputValue(Input.STD_A, LogicValue.L1);

		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_2"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_3"))
				.setInputValue(Input.STD_A, LogicValue.L0);

		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_4"))
				.setInputValue(Input.STD_A, LogicValue.L1);

		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_5"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_6"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_7"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_8"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_9"))
				.setInputValue(Input.STD_A, LogicValue.L1);

		// Schaltung simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);

		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);

		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);

		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);

		assertTrue(
				"Belegung des Lampe24 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_24"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);

		assertTrue(
				"Belegung des Lampe25 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_25"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);

		assertTrue(
				"Belegung des Lampe26 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_26"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter:
	 * Schalter1: undefiniert, Schalter2: L1, Schalter3: undefiniert, Schalter4:
	 * undefiniert, Schalter5: L1, Schalter6: L0, Schalter7: undefiniert,
	 * Schalter8: undefiniert, Schalter9: L0
	 * 
	 */
	@Test
	public void testBelegung3() {

		// Schalter setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_1"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_2"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_3"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_4"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_5"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_6"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_7"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_8"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_9"))
				.setInputValue(Input.STD_A, LogicValue.L0);

		// Schaltung simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);

		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);

		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);

		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);

		assertTrue(
				"Belegung des Lampe24 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_24"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);

		assertTrue(
				"Belegung des Lampe25 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_25"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);

		assertTrue(
				"Belegung des Lampe26 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_26"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter:
	 * Schalter1: L0, Schalter2: undefiniert, Schalter3: L1, Schalter4: L1,
	 * Schalter5: L0, Schalter6: L1, Schalter7: L1, Schalter8: L1, Schalter9: L0
	 */
	@Test
	public void testBelegung4() {

		// Schalter setzen
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_1"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_2"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_3"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_4"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_5"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_6"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_7"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_8"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_9"))
				.setInputValue(Input.STD_A, LogicValue.L0);

		// Schaltung simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);

		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);

		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);

		assertTrue(
				"Belegung des Lampe24 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_24"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe25 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_25"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);
		assertTrue(
				"Belegung des Lampe26 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_26"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter:
	 * Schalte1: L0, Schalter2: L1, Schalter3: L1, Schalter4: L0, Schalter5:
	 * undefiniert, Schalter6: L1, Schalter7: L1, Schalter8: L1, Schalter9: L1
	 */
	@Test
	public void testBelegung5() {

		// Schalter setzen
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_1"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_2"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_3"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_4"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_5"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_6"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_7"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_8"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_9"))
				.setInputValue(Input.STD_A, LogicValue.L1);

		// Schaltung simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe24 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_24"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe25 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_25"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);
		assertTrue(
				"Belegung des Lampe26 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_26"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter:
	 * Schalter1: L1, Schalter2: undefiniert, Schalter3: L0, Schalter4: L1,
	 * Schalter5: L1, Schalter6: undefiniert, Schalter7: L1, Schalter8: L1,
	 * Schalter9: undefiniert
	 */
	@Test
	public void testBelegung6() {

		// Schalter setzen
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_1"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_2"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_3"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_4"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_5"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_6"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_7"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_8"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_9"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);

		// Schaltung simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);
		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe24 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_24"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe25 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_25"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe26 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_26"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
	}

	/**
	 * private HilfsMethode zur Berechnung der Schalter
	 */
	private void calcSwitches() {

		// Schalter berechnen
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_1")).calcLogicValue();
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_2")).calcLogicValue();
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_3")).calcLogicValue();
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_4")).calcLogicValue();
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_5")).calcLogicValue();
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_6")).calcLogicValue();
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_7")).calcLogicValue();
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_8")).calcLogicValue();
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("swit_9")).calcLogicValue();
		sModel.calcElementsToCalc();
	}
}
